#ifndef __INTEL32_DEFS__
#define __INTEL32_DEFS__

//////////////////////////////////////////////////////////////////////////
//COMPILER DIRECTIVE
//////////////////////////////////////////////////////////////////////////
#pragma warning(disable : 4996)
#pragma warning(disable : 4180)
#pragma warning(disable : 4267)
#pragma warning(disable : 4786)

//////////////////////////////////////////////////////////////////////////
// SYSTEM INCLUDE DIRECTIVES
//////////////////////////////////////////////////////////////////////////
//#include <pthread.h>
#include <assert.h>
#include <stdlib.h>

//////////////////////////////////////////////////////////////////////////
// SYSTEM CONSTS
//////////////////////////////////////////////////////////////////////////
#define CACHE_LINE_SIZE	(64)

//////////////////////////////////////////////////////////////////////////
// SYSTEM TYPES
//////////////////////////////////////////////////////////////////////////
typedef unsigned char	_u8;
typedef unsigned short	_u16;
typedef unsigned int	_u32;
typedef long long		_u64;
typedef _u32			tick_t;

//////////////////////////////////////////////////////////////////////////
// SYSTEM MEMORY ALLOCATION
//////////////////////////////////////////////////////////////////////////
/*void* ALIGNED_MALLOC(size_t _s)	{
	unsigned char* rc1 = (unsigned char*)malloc(_s + CACHE_LINE_SIZE);
	unsigned char* rc2 = (unsigned char*) ((((size_t)rc1) + CACHE_LINE_SIZE) & ~(CACHE_LINE_SIZE - 1));
	unsigned char* data = rc2 - 1;
	*data = (unsigned char)(rc2 - rc1);
	return (void*)rc2;
}

void ALIGNED_FREE(void* _p) {
	unsigned char* data = ((unsigned  char*)_p) - 1;
	_p = ((unsigned char*)_p) - *data;
}*/

//////////////////////////////////////////////////////////////////////////
// SYSTEM FUNCTIONS
//////////////////////////////////////////////////////////////////////////
/*/roei extern "C" void __stdcall Sleep(unsigned long dwMilliseconds);*/
extern "C" unsigned __stdcall Sleep(unsigned int dwMilliseconds);
/*/roei extern "C" unsigned __int64 __stdcall GetTickCount64();

//#define usleep(_t)	Sleep(_t/1000u);
*/
#define random()	(rand()*rand())
#define srandom		srand

//////////////////////////////////////////////////////////////////////////
// SYSTEM CAS
//////////////////////////////////////////////////////////////////////////

extern "C"
{
	long	__cdecl _InterlockedCompareExchange( long volatile* dest, long exchange, long comp);
	long	__cdecl _InterlockedCompareExchangePointer( void* volatile * dest, void* exchange, void* comp);
}

#pragma intrinsic (_InterlockedCompareExchange)

#define ATOMIC_CAS(_d, _c, _x)	_InterlockedCompareExchange((long volatile*)_d, _x, _c)
#define ATOMIC_CASP(_d, _c, _x)	_InterlockedCompareExchangePointer((void* volatile *)_d, _x, _c)

//////////////////////////////////////////////////////////////////////////
// SYSTEM MEMORY BARRIER
//////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////
// SYSTEM TIME
//////////////////////////////////////////////////////////////////////////
#define hrtime_t double 
//#define gethrtime() (clock()*1000000)
//#define sleep(n) Sleep(n/1000)
#define gethrtime() (((double)GetTickCount64())*1000000.0)

#endif
